Qual è la differenza tra "git pull" e "git fetch"?

1
2
Il prossimo
In termini più semplici, git pull esegue un git fetch seguito da un git merge.
Puoi eseguire un git fetch in qualsiasi momento per aggiornare i tuoi rami di tracciamento remoto in refs / remotes /  /.
Questa operazione non cambia mai nessuna delle tue filiali locali sotto refs / heads ed è sicura da fare senza cambiare la tua copia di lavoro. Ho persino sentito di persone che eseguono git fetch periodicamente in un cron job in background (anche se non consiglierei di farlo).
Un git pull è ciò che faresti per aggiornare un ramo locale con la sua versione remota, aggiornando anche gli altri rami di monitoraggio remoto.
Dalla documentazione di Git per git pull:
Nella sua modalità predefinita, git pull è l'abbreviazione di git fetch seguito da git merge FETCH_HEAD.
|
Quando usi pull, Git cerca di fare automaticamente il tuo lavoro per te. È sensibile al contesto, quindi Git unirà tutti i commit estratti nel ramo in cui stai attualmente lavorando. Pull unisce automaticamente i commit senza permetterti di esaminarli prima. Se non gestisci da vicino le tue filiali, potresti incorrere in frequenti conflitti.
Quando scarichi, Git raccoglie tutti i commit dal ramo di destinazione che non esistono nel tuo ramo corrente e li memorizza nel tuo repository locale. Tuttavia, non li unisce al tuo ramo attuale. Ciò è particolarmente utile se è necessario mantenere aggiornato il repository, ma si sta lavorando a qualcosa che potrebbe non funzionare se si aggiornano i file.
Per integrare i commit nel tuo ramo principale, usi merge.
|
È importante confrontare la filosofia di progettazione di git con la filosofia di uno strumento di controllo del codice più tradizionale come SVN.
Subversion è stato progettato e realizzato con un modello client / server. Esiste un unico repository che è il server e diversi client possono recuperare il codice dal server, lavorarci sopra, quindi eseguire il commit di nuovo sul server. Il presupposto è che il client possa sempre contattare il server quando ha bisogno di eseguire un'operazione.
Git è stato progettato per supportare un modello più distribuito senza la necessità di un repository centrale (anche se puoi certamente usarne uno se lo desideri). Inoltre git è stato progettato in modo che il client e il "server" non debbano essere online contemporaneamente. Git è stato progettato in modo che le persone su un collegamento inaffidabile potessero scambiare codice anche tramite e-mail. È possibile lavorare completamente disconnesso e masterizzare un CD per scambiare codice tramite git.
Per supportare questo modello, git mantiene un repository locale con il tuo codice e anche un repository locale aggiuntivo che rispecchia lo stato del repository remoto. Mantenendo una copia del repository remoto in locale, git può capire le modifiche necessarie anche quando il repository remoto non è raggiungibile. Successivamente, quando è necessario inviare le modifiche a qualcun altro, git può trasferirle come un insieme di modifiche da un momento noto al repository remoto.
git fetch è il comando che dice "aggiorna la mia copia locale del repository remoto".
git pull dice "porta le modifiche nel repository remoto dove tengo il mio codice".
Normalmente git pull lo fa eseguendo un git fetch per aggiornare la copia locale del repository remoto, quindi unendo le modifiche nel proprio repository di codice e possibilmente nella copia di lavoro.
Il trucco è tenere presente che spesso ci sono almeno tre copie di un progetto sulla tua workstation. Una copia è il tuo repository con la tua cronologia dei commit. La seconda copia è la tua copia di lavoro in cui stai modificando e costruendo. La terza copia è la tua copia locale "memorizzata nella cache" di un repository remoto.
|
Ecco l'immagine di Oliver Steele di come tutto funzioni insieme:
Se l'interesse è sufficiente, suppongo di poter aggiornare l'immagine per aggiungere git clone e git merge ...
|
Un caso d'uso di git fetch è che quanto segue ti dirà eventuali modifiche nel ramo remoto dall'ultimo pull ... quindi puoi controllare prima di eseguire un pull effettivo, che potrebbe cambiare i file nel ramo corrente e nella copia di lavoro.
git fetch
git diff ... origine
Vedere: https://git-scm.com/docs/git-diff per quanto riguarda la sintassi a doppio e triplo punto nel comando diff
|
Mi è costato un po 'capire quale fosse la differenza, ma questa è una semplice spiegazione. master nel tuo localhost è un ramo.
Quando cloni un repository, recuperi l'intero repository sul tuo host locale. Ciò significa che in quel momento hai un puntatore origine / master a HEAD e master che punta alla stessa HEAD.
quando inizi a lavorare ed esegui i commit, sposti il ​​puntatore principale su HEAD + i tuoi commit. Ma il puntatore origine / master punta ancora a quello che era quando hai clonato.
Quindi la differenza sarà:
Se esegui un git fetch, recupererà tutte le modifiche nel repository remoto (GitHub) e sposterà il puntatore origin / master su HEAD. Nel frattempo il tuo responsabile della filiale locale continuerà a indicare dove si trova.
Se esegui un git pull, sostanzialmente recupererà (come spiegato in precedenza) e unirà tutte le nuove modifiche al tuomaster branch e sposta il puntatore su HEAD.
|
A volte una rappresentazione visiva aiuta.
|
Brevemente
git fetch è simile a pull ma non si unisce. cioè recupera gli aggiornamenti remoti (ref e oggetti) ma il tuo locale rimane lo stesso (cioè l'origine / master viene aggiornato ma il master rimane lo stesso).
git pull si abbassa da un telecomando e si unisce istantaneamente.
Di Più
git clone clona un repo.
git rebase salva le cose dal tuo ramo attuale che non si trovano nel ramo a monte in un'area temporanea. Il tuo ramo ora è lo stesso di prima di iniziare le modifiche. Quindi, git pull -rebase tirerà giù le modifiche remote, riavvolgerà il tuo ramo locale, riprodurrà le tue modifiche sopra la parte superiore del tuo ramo corrente uno per uno finché non sarai aggiornato.
Inoltre, git branch -a ti mostrerà esattamente cosa sta succedendo con tutti i tuoi branch - locali e remoti.
Questo post del blog è stato utile:
La differenza tra git pull, git fetch e git clone (e git rebase) - Mike Pearce
e copre git pull, git fetch, git clone e git rebase.
====
AGGIORNARE
Ho pensato di aggiornarlo per mostrare come lo useresti effettivamente nella pratica.
Aggiorna il tuo repository locale dal remoto (ma non unire):
git fetch
Dopo aver scaricato gli aggiornamenti, vediamo le differenze:
git diff master origine / master
Se sei soddisfatto di questi aggiornamenti, unisci:
git pull
Appunti:
Al passaggio 2: per ulteriori informazioni sulle differenze tra locale e remoto, vedere: Come confrontare un ramo git locale con il suo ramo remoto?
Al passaggio 3: è probabilmente più accurato (ad esempio su un repo che cambia rapidamente) eseguire qui un'origine rebase git. Vedi il commento di @Justin Ohms in un'altra risposta.
Vedi anche: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Recupera da e unisci con un altro repository o un ramo locale
SINOSSI
git pull ...
DESCRIZIONE
Esegue git-fetch con i parametri dati e chiama git-merge per unire il file
testa recuperata nel ramo corrente. Con --rebase, chiama git-rebase
invece di git-merge.
Nota che puoi usare. (directory corrente) come  da estrarre
dal repository locale: è utile quando si uniscono rami locali
nel ramo corrente.
Si noti inoltre che le opzioni pensate per git-pull stesso e git-merge sottostante
deve essere fornito prima delle opzioni destinate a git-fetch.
Dovresti tirare se vuoi che le storie unite, prenderesti se semplicemente 'vuoi il codicez' poiché qualcuno ha taggato alcuni articoli qui intorno.
|
Puoi eseguire il recupero da un repository remoto, vedere le differenze e quindi eseguire il pull o unire.
Questo è un esempio per un repository remoto chiamato origin e un ramo chiamato master che traccia l'origine / master del ramo remoto:
git checkout master
git fetch
git diff origine / master
git rebase origin master
|
La risposta breve e facile è che git pull è semplicemente git fetch seguito da git merge.
È molto importante notare che git pull si unirà automaticamente che ti piaccia o no. Ciò potrebbe, ovviamente, provocare conflitti di fusione. Diciamo che il tuo telecomando è origin e il tuo ramo è master. Se git diff origin / master prima di estrarre, dovresti avere un'idea dei potenziali conflitti di unione e potresti preparare il tuo ramo locale di conseguenza.
Oltre a tirare e spingere, alcuni flussi di lavoro coinvolgono git rebase, come questo, che ho parafrasato dall'articolo collegato:
git pull origin master
git checkout foo-branch
git rebase master
git push origin foo-branch
Se ti trovi in ​​una situazione del genere, potresti essere tentato di git pull --rebase. A meno che tu non sappia davvero cosa stai facendo, ti sconsiglio. Questo avviso proviene dalla pagina man di git-pull, versione 2.3.5:
Questa è una modalità di funzionamento potenzialmente pericolosa. Riscrive
storia, che non promette nulla di buono quando hai pubblicato quella storia
già. Non usare questa opzione a meno che tu non abbia letto git-rebase (1)
accuratamente.
|
OK, ecco alcune informazioni su git pull e git fetch, così puoi capire le differenze effettive ... in poche semplici parole, fetch ottiene i dati più recenti, ma non le modifiche al codice e non rovinerà il codice del ramo locale corrente , ma prendi le modifiche al codice e uniscilo al tuo ramo locale, continua a leggere per ottenere maggiori dettagli su ciascuno:
git fetch
Scaricherà tutti i riferimenti e gli oggetti e qualsiasi nuovo ramo nel tuo repository locale ...
Recupera rami e / o tag (collettivamente, "refs") da uno o più
altri repository, insieme agli oggetti necessari per completare il loro
storie. I rami di monitoraggio remoto vengono aggiornati (vedere la descrizione
di seguito per i modi per controllare questo comportamento).
Per impostazione predefinita, qualsiasi tag che punta alle cronologie recuperate è
anche recuperato; l'effetto è quello di recuperare i tag che puntano ai rami che
ti interessa. Questo comportamento predefinito può essere modificato utilizzando
le opzioni --tags o --no-tags o configurando
remote..tagOpt. Utilizzando un refspec che recupera i tag in modo esplicito,
puoi recuperare i tag che non puntano ai rami che ti interessano
anche dentro.
git fetch può recuperare daun singolo repository o URL con nome oppure
da più archivi contemporaneamente se viene fornito e c'è un file
telecomandi. voce nel file di configurazione. (Vedi git-config1).
Quando non viene specificato alcun telecomando, per impostazione predefinita sarà il telecomando di origine
utilizzato, a meno che non ci sia un ramo a monte configurato per la corrente
ramo.
I nomi dei ref che vengono recuperati, insieme ai nomi degli oggetti
puntano a, sono scritti in .git / FETCH_HEAD. Questa informazione potrebbe essere
utilizzato da script o altri comandi git, come git-pull.
git pull
Applicherà le modifiche da remoto al ramo corrente in locale ...
Incorpora le modifiche da un repository remoto nel ramo corrente.
Nella sua modalità predefinita, git pull è l'abbreviazione di git fetch seguito da
git merge FETCH_HEAD.
Più precisamente, git pull esegue git fetch con i parametri dati e
chiama git merge per unire le diramazioni recuperate nella corrente
ramo. Con --rebase, esegue git rebase invece di git merge.
dovrebbe essere il nome di un repository remoto passato a
git-fetch1. può nominare un riferimento remoto arbitrario (ad esempio,
il nome di un tag) o anche una raccolta di ref con corrispondente
rami di localizzazione remota (ad esempio, refs / heads /: refs / remotes / origin /),
ma di solito è il nome di un ramo nel repository remoto.
I valori predefiniti per e vengono letti dal file
Configurazione "remota" e "unione" per il ramo corrente come impostato da
git-branch --track.
Creo anche l'immagine qui sotto per mostrarti come git fetch e git pull lavorano insieme ...
|
Questa rappresentazione grafica interattiva è molto utile per comprendere git: http://ndpsoftware.com/git-cheatsheet.html
git fetch "scarica" ​​semplicemente le modifiche dal telecomando al tuo repository locale. git pull scarica le modifiche e le unisce nel tuo ramo corrente. "Nella sua modalità predefinita, git pull è l'abbreviazione di git fetch seguito da git merge FETCH_HEAD."
|
Bonus:
Parlando di pull & fetch nelle risposte precedenti, vorrei condividere un trucco interessante,
git pull --rebase
Questo comando sopra è il comando più utile nella mia vita di git che ha risparmiato un sacco di tempo.
Prima di inviare i tuoi nuovi commit al server, prova questo comando e sincronizzerà automaticamente le ultime modifiche al server (con un fetch + merge) e posizionerà il tuo commit in cima al log di git. Non c'è bisogno di preoccuparsi del pull / merge manuale.
Trova i dettagli su: http://gitolite.com/git-pull--rebase
|
Mi piace avere una rappresentazione visiva della situazione per cogliere queste cose. Forse anche altri sviluppatori vorrebbero vederlo, quindi ecco la mia aggiunta. Non sono del tutto sicuro che sia tutto corretto, quindi per favore commenta se trovi degli errori.
SISTEMA LOCALE
. ================================================== ===
=================. ================= =================== =============
REPOSITORY REMOTO. REPOSITORY REMOTO REPOSITORY LOCALE COPIA DI LAVORO
(ORIGINE)          . (CACHED)
per esempio,      . specchio del
un repository GitHub. . repo remoto
Può anche essere       .
più repository.
.
.
FETCH * ------------------> *
La tua cache locale del telecomando viene aggiornata con l'origine (o multiple
fonti esterne, ovvero la natura distribuita di git)
.
TIRARE   *------------------------------------------------ --------> *
le modifiche vengono unite direttamente nella tua copia locale. quando si verificano conflitti,
ti vengono chieste delle decisioni.
.
COMMETTERE            . * <--------------- *
Quando provieni, ad esempio, da subversion, potresti pensare che un commit
aggiornerà l'origine. In git, viene eseguito un commit solo sul repository locale.
.
PUSH * <--------------------------------------- *
Sincronizza di nuovo le modifiche nell'origine.
Alcuni dei principali vantaggi per avere un mirror recuperato del telecomando sono:
Prestazioni (scorri tutti i commit ei messaggi senza cercare di spremerlo attraverso la rete)
Feedback sullo stato del tuo repository locale (ad esempio, uso SourceTree di Atlassian, che mi darà una lampadina che indica se sono in anticipo o in ritardo rispetto all'origine. Queste informazioni possono essere aggiornate con un GIT FETCH).
|
Ho lottato anche con questo. In effetti sono arrivato qui con una ricerca su Google della stessa identica domanda. La lettura di tutte queste risposte ha finalmente dipinto un'immagine nella mia testa e ho deciso di provare a rimuoverla osservando lo stato dei 2 repository e 1 sandbox e le azioni eseguite nel tempo mentre ne guardavo la versione. Quindi ecco cosa ho pensato. Per favore correggimi se ho sbagliato da qualche parte.
I tre pronti contro termine con un recupero:
--------------------- ----------------------- ------ -----------------
- Repo remoto - - Repo remoto - - Repo remoto -
- - - viene spinto - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Repo locale - - Repo locale - - Repo locale -
- pull - - - - fetch -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Sandbox locale - - Sandbox locale - - Sandbox locale -
- Checkout - - nuovo lavoro svolto - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
I tre pronti contro termine con un tiro
--------------------- ----------------------- ------ -----------------
- Repo remoto - - Repo remoto - - Repo remoto -
- - - viene spinto - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Repo locale - - Repo locale - - Repo locale -
- tirare - - - - tirare -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Sandbox locale - - Sandbox locale - - Sandbox locale -
- Checkout - - nuovo lavoro svolto - - unito a R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Questo mi ha aiutato a capire perché un recupero è piuttosto importante.
|
La differenza tra GIT Fetch e GIT Pull può essere spiegata con il seguente scenario:
(Tenendo presente che le immagini parlano più delle parole!, Ho fornito una rappresentazione pittorica)
Facciamo un esempio che stai lavorando a un progetto con i membri del tuo team. Quindi ci sarà un ramo principale del progetto e tutti i contributori devono eseguirne il fork al proprio repository locale e quindi lavorare su questo ramo locale per modificare / aggiungere moduli, quindi reinserirlo nel ramo principale.
Così,
Lo stato iniziale dei due rami quando hai biforcato il progetto principale sul tuo repository locale sarà così: (A, B e C sono moduli già completati del progetto)
Ora, hai iniziato a lavorare sul nuovo modulo (supponiamo D) e quando hai completato il modulo D vuoi spingerlo al ramo principale, ma nel frattempo quello che succede è che uno dei tuoi compagni di squadra ha sviluppato il nuovo Modulo E, F e modificato C.
Quindi ora quello che è successo è che il tuo repository locale è privo del progresso originale del progetto e quindi spingere le tue modifiche al ramo principale può portare a conflitti e potrebbe causare il malfunzionamento del tuo Modulo D.
Per evitare tali problemi e per lavorare parallelamente allo stato di avanzamento originale del progetto ci sono due modi:
1. Git Fetch- Questo scaricherà tutte le modifiche che sono state fatte al progetto origin / main branch che non sono presenti nel tuo branch locale. E aspetterà che il comando Git Merge applichi le modifiche che sono state recuperate al tuo repository o ramo.
Quindi ora puoi monitorare attentamente i file prima di unirli al tuo repository. E puoi anche modificare D se necessario a causa della modifica C.
2. Git Pull: aggiornerà il tuo ramo locale con l'origine / ramo principale, cioè in realtà ciò che fa è una combinazione di Git Fetch e Git si fondono uno dopo l'altro.
Ma questo potrebbe causare conflitti, quindi è consigliabile utilizzare Git Pull con una copia pulita.
|
Diciamo semplicemente:
git pull == git fetch + git merge
Se esegui git pull, non è necessario unire i dati in locale. Se esegui git fetch, significa che devi eseguire git merge per ottenere il codice più recente sulla tua macchina locale. In caso contrario, il codice macchina locale non verrebbe modificato senza l'unione.
Quindi in Git Gui, quando recuperi, devi unire i dati. Fetch stesso non apporterà modifiche al codice nel tuo locale. Puoi verificarlo quando aggiorni il codice recuperando
una volta andare a prendere e vedere; il codice non cambierà. Quindi unisci ... Vedrai il codice modificato.
|
git fetch trasferisce il codice dal server remoto ai tuoi rami di tracciamento nel tuo repository locale. Se il tuo telecomando si chiama origin (l'impostazione predefinita), questi rami saranno all'interno di origin /, ad esempio origin / master, origin / mybranch-123, ecc. Questi non sono i tuoi rami attuali, sono copie locali di quei rami dal server .
git pull esegue un git fetch ma poi unisce anche il codice dal ramo di monitoraggio al tuo fileversione locale di quel ramo. Se non sei ancora pronto per queste modifiche, git fetch prima.
|
git fetch recupererà i rami remoti in modo che tu possa git diff o git unirli con il ramo corrente. git pull eseguirà il recupero sul dispositivo remoto tracciato dal ramo corrente e quindi unirà il risultato. Puoi usare git fetch per vedere se ci sono aggiornamenti al ramo remoto senza doverli unire al tuo ramo locale.
|
Git Fetch
Scarica le modifiche al tuo ramo locale dall'origine tramite il recupero. Fetch chiede al repository remoto tutti i commit che altri hanno fatto ma che non hai nel repository locale. Fetch scarica questi commit e li aggiunge al repository locale.
Git Merge
È possibile applicare le modifiche scaricate tramite fetch utilizzando il comando merge. Merge prenderà i commit recuperati dal fetch e proverà ad aggiungerli al tuo ramo locale. L'unione manterrà la cronologia dei commit delle modifiche locali in modo che quando condividi il tuo ramo con push, Git saprà come gli altri possono unire le tue modifiche.
Git Pull
Fetch and merge vengono eseguiti insieme abbastanza spesso da creare un comando che combina i due, pull. Pull esegue un recupero e quindi un'unione per aggiungere i commit scaricati nel tuo ramo locale.
|
In termini semplici, se stavi per salire su un aereo senza alcuna connessione Internet ... prima di partire potresti semplicemente fare git fetch origin . Recupererebbe tutte le modifiche nel tuo computer, ma lo manterrebbe separato dal tuo spazio di lavoro / sviluppo locale.
Sull'aereo, potresti apportare modifiche al tuo spazio di lavoro locale e poi unirlo a ciò che hai recuperato e risolvere potenziali conflitti di unione, il tutto senza una connessione a Internet. E a meno che qualcuno non abbia apportato nuove modifiche al repository remoto, una volta arrivato a destinazione dovresti eseguire git push origin  e andare a prendere il caffè.
Da questo fantastico tutorial Atlassian:
Il comando git fetch scarica commit, file e ref da un file
repository remoto nel tuo repository locale.
Il recupero è quello che fai quando vuoi vedere quello che hanno tutti gli altri
su cui stavo lavorando. È simile all'aggiornamento SVN in quanto ti consente di vedere
come è andata avanti la storia centrale, ma non ti obbliga a farlo
effettivamente unisci le modifiche nel tuo repository. Git isola
contenuto recuperato come da contenuto locale esistente, ha assolutamente
nessun effetto sul lavoro di sviluppo locale. Il contenuto recuperato deve essere estratto esplicitamente utilizzando il comando git checkout. Questo fa
recuperare un modo sicuro per rivedere i commit prima di integrarli con
il tuo repository locale.
Quando si scarica il contenuto da un repository remoto, sono disponibili i comandi git pull e git fetch per eseguire l'attività. Puoi considerare
git recupera la versione "sicura" dei due comandi. Verrà scaricato
il contenuto remoto, ma non aggiornare lo stato di lavoro del repository locale,
lasciando intatto il tuo lavoro attuale. git pull è il più aggressivo
in alternativa, scaricherà il contenuto remoto per il locale attivo
branch ed eseguire immediatamente git merge per creare un merge commit
per il nuovo contenuto remoto. Se hai modifiche in sospeso in corso
ciò causerà conflitti e darà il via alla risoluzione dei conflitti di unione
flusso.
Con git pull:
Non ottieni alcun isolamento.
Non è necessario estrarlo esplicitamente. Perché implicitamente fa un git merge.
La fase di fusione influenzerà il tuo sviluppo locale e potrebbe causare conflitti
Fondamentalmente NON è sicuro. È aggressivo.
A differenza di git fetch, dove influisce solo sui tuoi .git / refs / remotes, git pull influenzerà sia i tuoi .git / refs / remotes che .git / refs / heads /
Hmmm ... quindi se non sto aggiornando la copia di lavoro con git fetch, dove sto apportando le modifiche? Dove Git recupera i nuovi commit?
Ottima domanda. Lo mette da qualche parte isolato dalla tua copia di lavoro. Ma di nuovo dove? Scopriamolo.
Nella directory del tuo progetto (cioè, dove esegui i tuoi comandi git) fai:
ls. Questo mostrerà i file e le directory. Niente di interessante, lo so.
Ora esegui ls -a. Questo mostrerà i file punto, cioè i file che iniziano con. Sarai quindi in grado di vedere una directory denominata: .git.
Esegui cd .git. Questo ovviamente cambierà la tua directory.
Ora arriva la parte divertente; fare ls. Vedrai un elenco di directory. Stiamo cercando refs. Fare rif cd.
È interessante vedere cosa c'è dentro tutte le directory, ma concentriamoci su due di esse. teste e telecomandi. Usa cd per controllare anche al loro interno.
Qualsiasi git fetch che farai aggiornerà gli elementi nella directory /.git/refs/remotes. Non aggiornerà nulla nella directory /.git/refs/heads.
Qualsiasi git pull eseguirà prima il git fetch, aggiornerà gli elementi nella directory /.git/refs/remotes, quindi si unirà al tuo locale e quindi cambierà l'intestazione all'interno della directory /.git/refs/heads.
Un'ottima risposta correlata può essere trovata anche in Dove si colloca 'git fetch' ?.
Inoltre, cerca "Notazione barra" nel post sulle convenzioni di denominazione dei rami Git. Ti aiuta a capire meglio come Git inserisce le cosedirectory diverse.
Per vedere la differenza effettiva
Basta fare:
git fetch origin master
git checkout master
Se il master remoto è stato aggiornato riceverai un messaggio come questo:
Il tuo ramo è dietro "origine / master" di 2 commit e può essere fatto avanzare rapidamente.
(usa "git pull" per aggiornare il tuo ramo locale)
Se non hai recuperato e hai appena eseguito git checkout master, il tuo git locale non saprebbe che ci sono 2 commit aggiunti. E direbbe solo:
Già su "master"
Il tuo ramo è aggiornato con "origin / master".
Ma è obsoleto e sbagliato. È perché git ti darà feedback esclusivamente in base a ciò che sa. È ignaro dei nuovi commit che non ha ancora eliminato ...
C'è un modo per vedere le nuove modifiche apportate in remoto mentre si lavora sul ramo in locale?
Alcuni IDE (ad es.Xcode) sono super intelligenti e utilizzano il risultato di un git fetch e possono annotare le righe di codice che sono state modificate nel ramo remoto del tuo ramo di lavoro corrente. Se quella riga è stata modificata sia dalle modifiche locali che dal ramo remoto, quella riga viene annotata in rosso. Questo non è un conflitto di unione. È un potenziale conflitto di unione. È un avvertimento che puoi usare per risolvere il futuro conflitto di unione prima di eseguire git pull dal ramo remoto.
Suggerimento divertente:
Se hai recuperato un ramo remoto, ad es. ha fatto:
git fetch origin feature / 123
Quindi questo andrebbe nella directory dei telecomandi. Non è ancora disponibile nella tua directory locale. Tuttavia, semplifica il checkout a quel ramo remoto tramite DWIM (fai quello che intendo):
git checkout feature / 123
non devi più fare:
git checkout -b feature / 123 origin / feature / 123
Per saperne di più leggi qui
|
L'unica differenza tra git pull e git fetch è che:
git pull esegue il pull da un ramo remoto e lo unisce.
git fetch recupera solo dal ramo remoto ma non si unisce
cioè git pull = git fetch + git merge ...
|
Git consente di applicare i commit cronologicamente più vecchi dopo i commit più recenti.
Per questo motivo, l'atto di trasferire i commit tra i repository è suddiviso in due passaggi:
Copia di nuovi commit dal ramo remoto alla copia di questo ramo remoto all'interno del repository locale.
(operazione da repo a repo) master @ remote >> remote / origin / master @ local
Integrazione di nuovi commit nella filiale locale
(operazione inside-repo) remote / origin / master @ local >> master @ local
Esistono due modi per eseguire il passaggio 2. È possibile:
Esegui il fork del ramo locale dopo l'ultimo antenato comune e aggiungi nuovi commit parallelamente ai commit che sono unici per il repository locale, finalizzati dall'unione del commit e dalla chiusura del fork.
Inserisci nuovi commit dopo l'ultimo antenato comune e riapplica i commit univoci al repository locale.
Nella terminologia git, il passaggio 1 è git fetch, il passaggio 2 è git merge o git rebase
git pull è git fetch e git merge
|
Git ottiene il branch dell'ultima versione dal remoto al locale utilizzando due comandi:
git fetch: Git otterrà l'ultima versione da remoto a locale, ma non si unirà automaticamente.

git fetch origin master
git log -p master..origin / master
git merge origin / master
I comandi sopra indicano che scarica l'ultima versione del ramo principale da origin dal remoto al ramo master di origine. Quindi confronta il ramo principale locale e il ramo principale di origine. Infine, unisci.
git pull: Git otterrà l'ultima versione dal telecomando e si unirà al locale.

git pull origin master
Il comando precedente è l'equivalente di git fetch e git merge. In pratica git fetch potrebbe essere più sicuro perché prima dell'unione possiamo vedere le modifiche e decidere se unire.
|
Qual è la differenza tra git pull e git fetch?
Per capirlo, devi prima capire che il tuo git locale mantiene non solo il tuo repository locale, ma mantiene anche una copia locale del repository remoto.
git fetch aggiorna la tua copia locale del repository remoto. Ad esempio, se il tuo repository remoto è GitHub, potresti voler recuperare tutte le modifiche apportate nel repository remoto alla tua copia locale del repository remoto. Ciò ti consentirà di eseguire operazioni come confrontare o unire.
git pull d'altra parte porterà giù le modifiche nel repository remoto in cui mantieni il tuo codice. In genere, git pull eseguirà prima un git fetch per aggiornare la copia locale del repository remoto, quindi unirà le modifiche nel tuo repository di codice e possibilmente nella tua copia di lavoro.
|
git pull == (git fetch + git merge)
git fetch non cambia ai rami locali.
Se hai già un repository locale con una configurazione remota per il progetto desiderato, puoi prendere tutti i rami e i tag per il telecomando esistente usando git fetch. ... Fetch non apporta alcuna modifica ai rami locali, quindi sarà necessario unire un ramo remoto con un ramo locale accoppiato per incorporare le nuove modifiche al recupero. da GitHub
|
Una semplice rappresentazione grafica per principianti,
Qui,
git pull
recupererà il codicedal repository e rebase con il tuo locale ... in git pull c'è la possibilità che vengano creati nuovi commit.
ma in ,
git fetch
recupererà il codice dal repository e abbiamo bisogno di rebase manualmente usando git rebase
ad esempio: vado a prendere dal server master e lo rebase nel mio master locale.
1) git pull (il rebase verrà eseguito automaticamente):
git pull origin master
qui l'origine è il tuo repository remoto, il tuo ramo
2) git fetch (è necessario rebase manualmente):
git fetch origin master
recupererà le modifiche al server dall'origine. e sarà nel tuo locale finché non lo ridisegni da solo. dobbiamo risolvere i conflitti manualmente controllando i codici.
git rebase origin / master
questo rebase il codice in locale. prima assicurati di essere nel ramo giusto.
|
Cercando di essere chiaro e semplice.
Il comando git pull è in realtà una scorciatoia per git fetch seguito da git merge o dal comando git rebase a seconda della configurazione. Puoi configurare il tuo repository Git in modo che git pull sia un fetch seguito da un rebase.
|
In realtà Git mantiene una copia del tuo codice e
il repository remoto.
Il comando git fetch aggiorna la tua copia locale ottenendo i dati dal repository remoto. Il motivo per cui ne abbiamo bisogno è perché qualcun altro potrebbe aver apportato alcune modifiche al codice e tu vuoi tenerti aggiornato.
Il comando git pull porta le modifiche nel repository remoto dove conservi il tuo codice. Normalmente, git pull fa questo eseguendo prima un "git fetch" per aggiornare la copia locale del repository remoto, quindi unisce le modifiche al tuo repository di codice e possibilmente alla tua copia di lavoro.
|
1
2
Il prossimo
Domanda molto attiva. Guadagna 10 punti reputazione per rispondere a questa domanda. Il requisito di reputazione aiuta a proteggere questa domanda dallo spam e dalle attività di mancata risposta.
Non è la risposta che stai cercando? Sfoglia altre domande contrassegnate con git version-control git-pull git-fetch o fai la tua domanda.